home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / arts / kmedia2.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-09-11  |  50.8 KB  |  1,426 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef KMEDIA2_H
  4. #define KMEDIA2_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "artsflow.h"
  12.  
  13. namespace Arts {
  14. enum poState {posIdle = 0, posPlaying = 1, posPaused = 2};
  15. enum poCapabilities {capSeek = 1, capPause = 2};
  16. }
  17. namespace Arts {
  18. class ARTS_EXPORT poTime : public Arts::Type {
  19. public:
  20.     poTime();
  21.     poTime(long _a_seconds, long _a_ms, float _a_custom, const std::string& _a_customUnit);
  22.     poTime(Arts::Buffer& stream);
  23.     poTime(const poTime& copyType);
  24.     poTime& operator=(const poTime& assignType);
  25.     long seconds;
  26.     long ms;
  27.     float custom;
  28.     std::string customUnit;
  29.  
  30. // marshalling functions
  31.     void readType(Arts::Buffer& stream);
  32.     void writeType(Arts::Buffer& stream) const;
  33.     std::string _typeName() const;
  34. };
  35.  
  36. }
  37. namespace Arts {
  38. class PlayObject_private;
  39. class PlayObject;
  40. class PlayObjectFactory;
  41. class InputStream;
  42. class FileInputStream;
  43. class StdoutWriter;
  44. class StreamPlayObject;
  45. class PitchablePlayObject;
  46. class VideoPlayObject;
  47. class PlayObjectFactoryV2;
  48.  
  49. class ARTS_EXPORT PlayObject_private_base : virtual public Arts::Object_base {
  50. public:
  51.     static unsigned long _IID; // interface ID
  52.  
  53.     static PlayObject_private_base *_create(const std::string& subClass = "Arts::PlayObject_private");
  54.     static PlayObject_private_base *_fromString(const std::string& objectref);
  55.     static PlayObject_private_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  56.  
  57.     static PlayObject_private_base *_fromDynamicCast(const Arts::Object& object);
  58.     inline PlayObject_private_base *_copy() {
  59.         assert(_refCnt > 0);
  60.         _refCnt++;
  61.         return this;
  62.     }
  63.  
  64.     virtual std::vector<std::string> _defaultPortsIn() const;
  65.     virtual std::vector<std::string> _defaultPortsOut() const;
  66.  
  67.     void *_cast(unsigned long iid);
  68.  
  69.     virtual bool loadMedia(const std::string& filename) = 0;
  70. };
  71.  
  72. class ARTS_EXPORT PlayObject_private_stub : virtual public PlayObject_private_base, virtual public Arts::Object_stub {
  73. protected:
  74.     PlayObject_private_stub();
  75.  
  76. public:
  77.     PlayObject_private_stub(Arts::Connection *connection, long objectID);
  78.  
  79.     bool loadMedia(const std::string& filename);
  80. };
  81.  
  82. class ARTS_EXPORT PlayObject_private_skel : virtual public PlayObject_private_base, virtual public Arts::Object_skel {
  83. public:
  84.     PlayObject_private_skel();
  85.  
  86.     static std::string _interfaceNameSkel();
  87.     std::string _interfaceName();
  88.     bool _isCompatibleWith(const std::string& interfacename);
  89.     void _buildMethodTable();
  90.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  91. };
  92.  
  93. }
  94. #include "reference.h"
  95. namespace Arts {
  96. class ARTS_EXPORT PlayObject_private : public Arts::Object {
  97. private:
  98.     static Arts::Object_base* _Creator();
  99.     PlayObject_private_base *_cache;
  100.     inline PlayObject_private_base *_method_call() {
  101.         _pool->checkcreate();
  102.         if(_pool->base) {
  103.             _cache=(PlayObject_private_base *)_pool->base->_cast(PlayObject_private_base::_IID);
  104.             assert(_cache);
  105.         }
  106.         return _cache;
  107.     }
  108.  
  109. protected:
  110.     inline PlayObject_private(PlayObject_private_base* b) : Arts::Object(b), _cache(0) {}
  111.  
  112.  
  113. public:
  114.     typedef PlayObject_private_base _base_class;
  115.  
  116.     inline PlayObject_private() : Arts::Object(_Creator), _cache(0) {}
  117.     inline PlayObject_private(const Arts::SubClass& s) :
  118.         Arts::Object(PlayObject_private_base::_create(s.string())), _cache(0) {}
  119.     inline PlayObject_private(const Arts::Reference &r) :
  120.         Arts::Object(r.isString()?(PlayObject_private_base::_fromString(r.string())):(PlayObject_private_base::_fromReference(r.reference(),true))), _cache(0) {}
  121.     inline PlayObject_private(const Arts::DynamicCast& c) : Arts::Object(PlayObject_private_base::_fromDynamicCast(c.object())), _cache(0) {}
  122.     inline PlayObject_private(const PlayObject_private& target) : Arts::Object(target._pool), _cache(target._cache) {}
  123.     inline PlayObject_private(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  124.     inline static PlayObject_private null() {return PlayObject_private((PlayObject_private_base*)0);}
  125.     inline static PlayObject_private _from_base(PlayObject_private_base* b) {return PlayObject_private(b);}
  126.     inline PlayObject_private& operator=(const PlayObject_private& target) {
  127.         if (_pool == target._pool) return *this;
  128.         _pool->Dec();
  129.         _pool = target._pool;
  130.         _cache = target._cache;
  131.         _pool->Inc();
  132.         return *this;
  133.     }
  134.     inline PlayObject_private_base* _base() {return _cache?_cache:_method_call();}
  135.  
  136.     inline bool loadMedia(const std::string& filename);
  137. };
  138.  
  139. class ARTS_EXPORT PlayObject_base : virtual public Arts::PlayObject_private_base {
  140. public:
  141.     static unsigned long _IID; // interface ID
  142.  
  143.     static PlayObject_base *_create(const std::string& subClass = "Arts::PlayObject");
  144.     static PlayObject_base *_fromString(const std::string& objectref);
  145.     static PlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  146.  
  147.     static PlayObject_base *_fromDynamicCast(const Arts::Object& object);
  148.     inline PlayObject_base *_copy() {
  149.         assert(_refCnt > 0);
  150.         _refCnt++;
  151.         return this;
  152.     }
  153.  
  154.     virtual std::vector<std::string> _defaultPortsIn() const;
  155.     virtual std::vector<std::string> _defaultPortsOut() const;
  156.  
  157.     void *_cast(unsigned long iid);
  158.  
  159.     virtual std::string description() = 0;
  160.     virtual Arts::poTime currentTime() = 0;
  161.     virtual Arts::poTime overallTime() = 0;
  162.     virtual Arts::poCapabilities capabilities() = 0;
  163.     virtual std::string mediaName() = 0;
  164.     virtual Arts::poState state() = 0;
  165.     virtual void play() = 0;
  166.     virtual void seek(const Arts::poTime& newTime) = 0;
  167.     virtual void pause() = 0;
  168.     virtual void halt() = 0;
  169. };
  170.  
  171. class ARTS_EXPORT PlayObject_stub : virtual public PlayObject_base, virtual public Arts::PlayObject_private_stub {
  172. protected:
  173.     PlayObject_stub();
  174.  
  175. public:
  176.     PlayObject_stub(Arts::Connection *connection, long objectID);
  177.  
  178.     std::string description();
  179.     Arts::poTime currentTime();
  180.     Arts::poTime overallTime();
  181.     Arts::poCapabilities capabilities();
  182.     std::string mediaName();
  183.     Arts::poState state();
  184.     void play();
  185.     void seek(const Arts::poTime& newTime);
  186.     void pause();
  187.     void halt();
  188. };
  189.  
  190. class ARTS_EXPORT PlayObject_skel : virtual public PlayObject_base, virtual public Arts::PlayObject_private_skel {
  191. protected:
  192.     // emitters for change notifications
  193.     inline void description_changed(const std::string& newValue) {
  194.         _emit_changed("description_changed",newValue);
  195.     }
  196.     inline void capabilities_changed(Arts::poCapabilities newValue) {
  197.         _emit_changed("capabilities_changed",newValue);
  198.     }
  199.     inline void mediaName_changed(const std::string& newValue) {
  200.         _emit_changed("mediaName_changed",newValue);
  201.     }
  202.     inline void state_changed(Arts::poState newValue) {
  203.         _emit_changed("state_changed",newValue);
  204.     }
  205.  
  206. public:
  207.     PlayObject_skel();
  208.  
  209.     static std::string _interfaceNameSkel();
  210.     std::string _interfaceName();
  211.     bool _isCompatibleWith(const std::string& interfacename);
  212.     void _buildMethodTable();
  213.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  214. };
  215.  
  216. }
  217. #include "reference.h"
  218. namespace Arts {
  219. class ARTS_EXPORT PlayObject : public Arts::Object {
  220. private:
  221.     static Arts::Object_base* _Creator();
  222.     PlayObject_base *_cache;
  223.     inline PlayObject_base *_method_call() {
  224.         _pool->checkcreate();
  225.         if(_pool->base) {
  226.             _cache=(PlayObject_base *)_pool->base->_cast(PlayObject_base::_IID);
  227.             assert(_cache);
  228.         }
  229.         return _cache;
  230.     }
  231.  
  232. protected:
  233.     inline PlayObject(PlayObject_base* b) : Arts::Object(b), _cache(0) {}
  234.  
  235.  
  236. public:
  237.     typedef PlayObject_base _base_class;
  238.  
  239.     inline PlayObject() : Arts::Object(_Creator), _cache(0) {}
  240.     inline PlayObject(const Arts::SubClass& s) :
  241.         Arts::Object(PlayObject_base::_create(s.string())), _cache(0) {}
  242.     inline PlayObject(const Arts::Reference &r) :
  243.         Arts::Object(r.isString()?(PlayObject_base::_fromString(r.string())):(PlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
  244.     inline PlayObject(const Arts::DynamicCast& c) : Arts::Object(PlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
  245.     inline PlayObject(const PlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
  246.     inline PlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  247.     inline static PlayObject null() {return PlayObject((PlayObject_base*)0);}
  248.     inline static PlayObject _from_base(PlayObject_base* b) {return PlayObject(b);}
  249.     inline PlayObject& operator=(const PlayObject& target) {
  250.         if (_pool == target._pool) return *this;
  251.         _pool->Dec();
  252.         _pool = target._pool;
  253.         _cache = target._cache;
  254.         _pool->Inc();
  255.         return *this;
  256.     }
  257.     inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
  258.     inline PlayObject_base* _base() {return _cache?_cache:_method_call();}
  259.  
  260.     inline bool loadMedia(const std::string& filename);
  261.     inline std::string description();
  262.     inline Arts::poTime currentTime();
  263.     inline Arts::poTime overallTime();
  264.     inline Arts::poCapabilities capabilities();
  265.     inline std::string mediaName();
  266.     inline Arts::poState state();
  267.     inline void play();
  268.     inline void seek(const Arts::poTime& newTime);
  269.     inline void pause();
  270.     inline void halt();
  271. };
  272.  
  273. class ARTS_EXPORT PlayObjectFactory_base : virtual public Arts::Object_base {
  274. public:
  275.     static unsigned long _IID; // interface ID
  276.  
  277.     static PlayObjectFactory_base *_create(const std::string& subClass = "Arts::PlayObjectFactory");
  278.     static PlayObjectFactory_base *_fromString(const std::string& objectref);
  279.     static PlayObjectFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  280.  
  281.     static PlayObjectFactory_base *_fromDynamicCast(const Arts::Object& object);
  282.     inline PlayObjectFactory_base *_copy() {
  283.         assert(_refCnt > 0);
  284.         _refCnt++;
  285.         return this;
  286.     }
  287.  
  288.     virtual std::vector<std::string> _defaultPortsIn() const;
  289.     virtual std::vector<std::string> _defaultPortsOut() const;
  290.  
  291.     void *_cast(unsigned long iid);
  292.  
  293.     virtual Arts::PlayObject createPlayObject(const std::string& filename) = 0;
  294. };
  295.  
  296. class ARTS_EXPORT PlayObjectFactory_stub : virtual public PlayObjectFactory_base, virtual public Arts::Object_stub {
  297. protected:
  298.     PlayObjectFactory_stub();
  299.  
  300. public:
  301.     PlayObjectFactory_stub(Arts::Connection *connection, long objectID);
  302.  
  303.     Arts::PlayObject createPlayObject(const std::string& filename);
  304. };
  305.  
  306. class ARTS_EXPORT PlayObjectFactory_skel : virtual public PlayObjectFactory_base, virtual public Arts::Object_skel {
  307. public:
  308.     PlayObjectFactory_skel();
  309.  
  310.     static std::string _interfaceNameSkel();
  311.     std::string _interfaceName();
  312.     bool _isCompatibleWith(const std::string& interfacename);
  313.     void _buildMethodTable();
  314.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  315. };
  316.  
  317. }
  318. #include "reference.h"
  319. namespace Arts {
  320. class ARTS_EXPORT PlayObjectFactory : public Arts::Object {
  321. private:
  322.     static Arts::Object_base* _Creator();
  323.     PlayObjectFactory_base *_cache;
  324.     inline PlayObjectFactory_base *_method_call() {
  325.         _pool->checkcreate();
  326.         if(_pool->base) {
  327.             _cache=(PlayObjectFactory_base *)_pool->base->_cast(PlayObjectFactory_base::_IID);
  328.             assert(_cache);
  329.         }
  330.         return _cache;
  331.     }
  332.  
  333. protected:
  334.     inline PlayObjectFactory(PlayObjectFactory_base* b) : Arts::Object(b), _cache(0) {}
  335.  
  336.  
  337. public:
  338.     typedef PlayObjectFactory_base _base_class;
  339.  
  340.     inline PlayObjectFactory() : Arts::Object(_Creator), _cache(0) {}
  341.     inline PlayObjectFactory(const Arts::SubClass& s) :
  342.         Arts::Object(PlayObjectFactory_base::_create(s.string())), _cache(0) {}
  343.     inline PlayObjectFactory(const Arts::Reference &r) :
  344.         Arts::Object(r.isString()?(PlayObjectFactory_base::_fromString(r.string())):(PlayObjectFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  345.     inline PlayObjectFactory(const Arts::DynamicCast& c) : Arts::Object(PlayObjectFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  346.     inline PlayObjectFactory(const PlayObjectFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  347.     inline PlayObjectFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  348.     inline static PlayObjectFactory null() {return PlayObjectFactory((PlayObjectFactory_base*)0);}
  349.     inline static PlayObjectFactory _from_base(PlayObjectFactory_base* b) {return PlayObjectFactory(b);}
  350.     inline PlayObjectFactory& operator=(const PlayObjectFactory& target) {
  351.         if (_pool == target._pool) return *this;
  352.         _pool->Dec();
  353.         _pool = target._pool;
  354.         _cache = target._cache;
  355.         _pool->Inc();
  356.         return *this;
  357.     }
  358.     inline PlayObjectFactory_base* _base() {return _cache?_cache:_method_call();}
  359.  
  360.     inline Arts::PlayObject createPlayObject(const std::string& filename);
  361. };
  362.  
  363. class ARTS_EXPORT InputStream_base : virtual public Arts::SynthModule_base {
  364. public:
  365.     static unsigned long _IID; // interface ID
  366.  
  367.     static InputStream_base *_create(const std::string& subClass = "Arts::InputStream");
  368.     static InputStream_base *_fromString(const std::string& objectref);
  369.     static InputStream_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  370.  
  371.     static InputStream_base *_fromDynamicCast(const Arts::Object& object);
  372.     inline InputStream_base *_copy() {
  373.         assert(_refCnt > 0);
  374.         _refCnt++;
  375.         return this;
  376.     }
  377.  
  378.     virtual std::vector<std::string> _defaultPortsIn() const;
  379.     virtual std::vector<std::string> _defaultPortsOut() const;
  380.  
  381.     void *_cast(unsigned long iid);
  382.  
  383.     virtual bool eof() = 0;
  384.     virtual long size() = 0;
  385.     virtual bool seekOk() = 0;
  386.     virtual long seek(long position) = 0;
  387. };
  388.  
  389. class ARTS_EXPORT InputStream_stub : virtual public InputStream_base, virtual public Arts::SynthModule_stub {
  390. protected:
  391.     InputStream_stub();
  392.  
  393. public:
  394.     InputStream_stub(Arts::Connection *connection, long objectID);
  395.  
  396.     bool eof();
  397.     long size();
  398.     bool seekOk();
  399.     long seek(long position);
  400. };
  401.  
  402. class ARTS_EXPORT InputStream_skel : virtual public InputStream_base, virtual public Arts::SynthModule_skel {
  403. protected:
  404.     // variables for streams
  405.     Arts::ByteAsyncStream outdata;            // outgoing stream
  406.  
  407.     // handler for asynchronous streams
  408.     virtual void request_outdata(Arts::DataPacket<Arts::mcopbyte> *);
  409.  
  410. protected:
  411.     // emitters for change notifications
  412.     inline void eof_changed(bool newValue) {
  413.         _emit_changed("eof_changed",newValue);
  414.     }
  415.     inline void size_changed(long newValue) {
  416.         _emit_changed("size_changed",newValue);
  417.     }
  418.     inline void seekOk_changed(bool newValue) {
  419.         _emit_changed("seekOk_changed",newValue);
  420.     }
  421.  
  422. public:
  423.     InputStream_skel();
  424.  
  425.     static std::string _interfaceNameSkel();
  426.     std::string _interfaceName();
  427.     bool _isCompatibleWith(const std::string& interfacename);
  428.     void _buildMethodTable();
  429.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  430.     void notify(const Arts::Notification& notification);
  431. };
  432.  
  433. }
  434. #include "reference.h"
  435. namespace Arts {
  436. class ARTS_EXPORT InputStream : public Arts::Object {
  437. private:
  438.     static Arts::Object_base* _Creator();
  439.     InputStream_base *_cache;
  440.     inline InputStream_base *_method_call() {
  441.         _pool->checkcreate();
  442.         if(_pool->base) {
  443.             _cache=(InputStream_base *)_pool->base->_cast(InputStream_base::_IID);
  444.             assert(_cache);
  445.         }
  446.         return _cache;
  447.     }
  448.  
  449. protected:
  450.     inline InputStream(InputStream_base* b) : Arts::Object(b), _cache(0) {}
  451.  
  452.  
  453. public:
  454.     typedef InputStream_base _base_class;
  455.  
  456.     inline InputStream() : Arts::Object(_Creator), _cache(0) {}
  457.     inline InputStream(const Arts::SubClass& s) :
  458.         Arts::Object(InputStream_base::_create(s.string())), _cache(0) {}
  459.     inline InputStream(const Arts::Reference &r) :
  460.         Arts::Object(r.isString()?(InputStream_base::_fromString(r.string())):(InputStream_base::_fromReference(r.reference(),true))), _cache(0) {}
  461.     inline InputStream(const Arts::DynamicCast& c) : Arts::Object(InputStream_base::_fromDynamicCast(c.object())), _cache(0) {}
  462.     inline InputStream(const InputStream& target) : Arts::Object(target._pool), _cache(target._cache) {}
  463.     inline InputStream(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  464.     inline static InputStream null() {return InputStream((InputStream_base*)0);}
  465.     inline static InputStream _from_base(InputStream_base* b) {return InputStream(b);}
  466.     inline InputStream& operator=(const InputStream& target) {
  467.         if (_pool == target._pool) return *this;
  468.         _pool->Dec();
  469.         _pool = target._pool;
  470.         _cache = target._cache;
  471.         _pool->Inc();
  472.         return *this;
  473.     }
  474.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  475.     inline InputStream_base* _base() {return _cache?_cache:_method_call();}
  476.  
  477.     inline Arts::AutoSuspendState autoSuspend();
  478.     inline void start();
  479.     inline void stop();
  480.     inline void streamInit();
  481.     inline void streamStart();
  482.     inline void streamEnd();
  483.     inline bool eof();
  484.     inline long size();
  485.     inline bool seekOk();
  486.     inline long seek(long position);
  487. };
  488.  
  489. class ARTS_EXPORT FileInputStream_base : virtual public Arts::InputStream_base {
  490. public:
  491.     static unsigned long _IID; // interface ID
  492.  
  493.     static FileInputStream_base *_create(const std::string& subClass = "Arts::FileInputStream");
  494.     static FileInputStream_base *_fromString(const std::string& objectref);
  495.     static FileInputStream_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  496.  
  497.     static FileInputStream_base *_fromDynamicCast(const Arts::Object& object);
  498.     inline FileInputStream_base *_copy() {
  499.         assert(_refCnt > 0);
  500.         _refCnt++;
  501.         return this;
  502.     }
  503.  
  504.     virtual std::vector<std::string> _defaultPortsIn() const;
  505.     virtual std::vector<std::string> _defaultPortsOut() const;
  506.  
  507.     void *_cast(unsigned long iid);
  508.  
  509.     virtual std::string filename() = 0;
  510.     virtual void filename(const std::string& newValue) = 0;
  511.     virtual bool open(const std::string& filename) = 0;
  512. };
  513.  
  514. class ARTS_EXPORT FileInputStream_stub : virtual public FileInputStream_base, virtual public Arts::InputStream_stub {
  515. protected:
  516.     FileInputStream_stub();
  517.  
  518. public:
  519.     FileInputStream_stub(Arts::Connection *connection, long objectID);
  520.  
  521.     std::string filename();
  522.     void filename(const std::string& newValue);
  523.     bool open(const std::string& filename);
  524. };
  525.  
  526. class ARTS_EXPORT FileInputStream_skel : virtual public FileInputStream_base, virtual public Arts::InputStream_skel {
  527. protected:
  528.     // emitters for change notifications
  529.     inline void filename_changed(const std::string& newValue) {
  530.         _emit_changed("filename_changed",newValue);
  531.     }
  532.  
  533. public:
  534.     FileInputStream_skel();
  535.  
  536.     static std::string _interfaceNameSkel();
  537.     std::string _interfaceName();
  538.     bool _isCompatibleWith(const std::string& interfacename);
  539.     void _buildMethodTable();
  540.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  541. };
  542.  
  543. }
  544. #include "reference.h"
  545. namespace Arts {
  546. class ARTS_EXPORT FileInputStream : public Arts::Object {
  547. private:
  548.     static Arts::Object_base* _Creator();
  549.     FileInputStream_base *_cache;
  550.     inline FileInputStream_base *_method_call() {
  551.         _pool->checkcreate();
  552.         if(_pool->base) {
  553.             _cache=(FileInputStream_base *)_pool->base->_cast(FileInputStream_base::_IID);
  554.             assert(_cache);
  555.         }
  556.         return _cache;
  557.     }
  558.  
  559. protected:
  560.     inline FileInputStream(FileInputStream_base* b) : Arts::Object(b), _cache(0) {}
  561.  
  562.  
  563. public:
  564.     typedef FileInputStream_base _base_class;
  565.  
  566.     inline FileInputStream() : Arts::Object(_Creator), _cache(0) {}
  567.     inline FileInputStream(const Arts::SubClass& s) :
  568.         Arts::Object(FileInputStream_base::_create(s.string())), _cache(0) {}
  569.     inline FileInputStream(const Arts::Reference &r) :
  570.         Arts::Object(r.isString()?(FileInputStream_base::_fromString(r.string())):(FileInputStream_base::_fromReference(r.reference(),true))), _cache(0) {}
  571.     inline FileInputStream(const Arts::DynamicCast& c) : Arts::Object(FileInputStream_base::_fromDynamicCast(c.object())), _cache(0) {}
  572.     inline FileInputStream(const FileInputStream& target) : Arts::Object(target._pool), _cache(target._cache) {}
  573.     inline FileInputStream(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  574.     inline static FileInputStream null() {return FileInputStream((FileInputStream_base*)0);}
  575.     inline static FileInputStream _from_base(FileInputStream_base* b) {return FileInputStream(b);}
  576.     inline FileInputStream& operator=(const FileInputStream& target) {
  577.         if (_pool == target._pool) return *this;
  578.         _pool->Dec();
  579.         _pool = target._pool;
  580.         _cache = target._cache;
  581.         _pool->Inc();
  582.         return *this;
  583.     }
  584.     inline operator Arts::InputStream() const { return Arts::InputStream(*_pool); }
  585.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  586.     inline FileInputStream_base* _base() {return _cache?_cache:_method_call();}
  587.  
  588.     inline bool eof();
  589.     inline long size();
  590.     inline bool seekOk();
  591.     inline long seek(long position);
  592.     inline Arts::AutoSuspendState autoSuspend();
  593.     inline void start();
  594.     inline void stop();
  595.     inline void streamInit();
  596.     inline void streamStart();
  597.     inline void streamEnd();
  598.     inline std::string filename();
  599.     inline void filename(const std::string& _newValue);
  600.     inline bool open(const std::string& filename);
  601. };
  602.  
  603. class ARTS_EXPORT StdoutWriter_base : virtual public Arts::SynthModule_base {
  604. public:
  605.     static unsigned long _IID; // interface ID
  606.  
  607.     static StdoutWriter_base *_create(const std::string& subClass = "Arts::StdoutWriter");
  608.     static StdoutWriter_base *_fromString(const std::string& objectref);
  609.     static StdoutWriter_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  610.  
  611.     static StdoutWriter_base *_fromDynamicCast(const Arts::Object& object);
  612.     inline StdoutWriter_base *_copy() {
  613.         assert(_refCnt > 0);
  614.         _refCnt++;
  615.         return this;
  616.     }
  617.  
  618.     virtual std::vector<std::string> _defaultPortsIn() const;
  619.     virtual std::vector<std::string> _defaultPortsOut() const;
  620.  
  621.     void *_cast(unsigned long iid);
  622.  
  623. };
  624.  
  625. class ARTS_EXPORT StdoutWriter_stub : virtual public StdoutWriter_base, virtual public Arts::SynthModule_stub {
  626. protected:
  627.     StdoutWriter_stub();
  628.  
  629. public:
  630.     StdoutWriter_stub(Arts::Connection *connection, long objectID);
  631.  
  632. };
  633.  
  634. class ARTS_EXPORT StdoutWriter_skel : virtual public StdoutWriter_base, virtual public Arts::SynthModule_skel {
  635. protected:
  636.     // variables for streams
  637.     Arts::ByteAsyncStream indata;             // incoming stream
  638.  
  639.     // handler for asynchronous streams
  640.     virtual void process_indata(Arts::DataPacket<Arts::mcopbyte> *) = 0;
  641.  
  642. public:
  643.     StdoutWriter_skel();
  644.  
  645.     static std::string _interfaceNameSkel();
  646.     std::string _interfaceName();
  647.     bool _isCompatibleWith(const std::string& interfacename);
  648.     void _buildMethodTable();
  649.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  650.     void notify(const Arts::Notification& notification);
  651. };
  652.  
  653. }
  654. #include "reference.h"
  655. namespace Arts {
  656. class ARTS_EXPORT StdoutWriter : public Arts::Object {
  657. private:
  658.     static Arts::Object_base* _Creator();
  659.     StdoutWriter_base *_cache;
  660.     inline StdoutWriter_base *_method_call() {
  661.         _pool->checkcreate();
  662.         if(_pool->base) {
  663.             _cache=(StdoutWriter_base *)_pool->base->_cast(StdoutWriter_base::_IID);
  664.             assert(_cache);
  665.         }
  666.         return _cache;
  667.     }
  668.  
  669. protected:
  670.     inline StdoutWriter(StdoutWriter_base* b) : Arts::Object(b), _cache(0) {}
  671.  
  672.  
  673. public:
  674.     typedef StdoutWriter_base _base_class;
  675.  
  676.     inline StdoutWriter() : Arts::Object(_Creator), _cache(0) {}
  677.     inline StdoutWriter(const Arts::SubClass& s) :
  678.         Arts::Object(StdoutWriter_base::_create(s.string())), _cache(0) {}
  679.     inline StdoutWriter(const Arts::Reference &r) :
  680.         Arts::Object(r.isString()?(StdoutWriter_base::_fromString(r.string())):(StdoutWriter_base::_fromReference(r.reference(),true))), _cache(0) {}
  681.     inline StdoutWriter(const Arts::DynamicCast& c) : Arts::Object(StdoutWriter_base::_fromDynamicCast(c.object())), _cache(0) {}
  682.     inline StdoutWriter(const StdoutWriter& target) : Arts::Object(target._pool), _cache(target._cache) {}
  683.     inline StdoutWriter(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  684.     inline static StdoutWriter null() {return StdoutWriter((StdoutWriter_base*)0);}
  685.     inline static StdoutWriter _from_base(StdoutWriter_base* b) {return StdoutWriter(b);}
  686.     inline StdoutWriter& operator=(const StdoutWriter& target) {
  687.         if (_pool == target._pool) return *this;
  688.         _pool->Dec();
  689.         _pool = target._pool;
  690.         _cache = target._cache;
  691.         _pool->Inc();
  692.         return *this;
  693.     }
  694.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  695.     inline StdoutWriter_base* _base() {return _cache?_cache:_method_call();}
  696.  
  697.     inline Arts::AutoSuspendState autoSuspend();
  698.     inline void start();
  699.     inline void stop();
  700.     inline void streamInit();
  701.     inline void streamStart();
  702.     inline void streamEnd();
  703. };
  704.  
  705. class ARTS_EXPORT StreamPlayObject_base : virtual public Arts::PlayObject_base {
  706. public:
  707.     static unsigned long _IID; // interface ID
  708.  
  709.     static StreamPlayObject_base *_create(const std::string& subClass = "Arts::StreamPlayObject");
  710.     static StreamPlayObject_base *_fromString(const std::string& objectref);
  711.     static StreamPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  712.  
  713.     static StreamPlayObject_base *_fromDynamicCast(const Arts::Object& object);
  714.     inline StreamPlayObject_base *_copy() {
  715.         assert(_refCnt > 0);
  716.         _refCnt++;
  717.         return this;
  718.     }
  719.  
  720.     virtual std::vector<std::string> _defaultPortsIn() const;
  721.     virtual std::vector<std::string> _defaultPortsOut() const;
  722.  
  723.     void *_cast(unsigned long iid);
  724.  
  725.     virtual bool streamMedia(Arts::InputStream instream) = 0;
  726.     virtual Arts::InputStream inputStream() = 0;
  727. };
  728.  
  729. class ARTS_EXPORT StreamPlayObject_stub : virtual public StreamPlayObject_base, virtual public Arts::PlayObject_stub {
  730. protected:
  731.     StreamPlayObject_stub();
  732.  
  733. public:
  734.     StreamPlayObject_stub(Arts::Connection *connection, long objectID);
  735.  
  736.     bool streamMedia(Arts::InputStream instream);
  737.     Arts::InputStream inputStream();
  738. };
  739.  
  740. class ARTS_EXPORT StreamPlayObject_skel : virtual public StreamPlayObject_base, virtual public Arts::PlayObject_skel {
  741. public:
  742.     StreamPlayObject_skel();
  743.  
  744.     static std::string _interfaceNameSkel();
  745.     std::string _interfaceName();
  746.     bool _isCompatibleWith(const std::string& interfacename);
  747.     void _buildMethodTable();
  748.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  749. };
  750.  
  751. }
  752. #include "reference.h"
  753. namespace Arts {
  754. class ARTS_EXPORT StreamPlayObject : public Arts::Object {
  755. private:
  756.     static Arts::Object_base* _Creator();
  757.     StreamPlayObject_base *_cache;
  758.     inline StreamPlayObject_base *_method_call() {
  759.         _pool->checkcreate();
  760.         if(_pool->base) {
  761.             _cache=(StreamPlayObject_base *)_pool->base->_cast(StreamPlayObject_base::_IID);
  762.             assert(_cache);
  763.         }
  764.         return _cache;
  765.     }
  766.  
  767. protected:
  768.     inline StreamPlayObject(StreamPlayObject_base* b) : Arts::Object(b), _cache(0) {}
  769.  
  770.  
  771. public:
  772.     typedef StreamPlayObject_base _base_class;
  773.  
  774.     inline StreamPlayObject() : Arts::Object(_Creator), _cache(0) {}
  775.     inline StreamPlayObject(const Arts::SubClass& s) :
  776.         Arts::Object(StreamPlayObject_base::_create(s.string())), _cache(0) {}
  777.     inline StreamPlayObject(const Arts::Reference &r) :
  778.         Arts::Object(r.isString()?(StreamPlayObject_base::_fromString(r.string())):(StreamPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
  779.     inline StreamPlayObject(const Arts::DynamicCast& c) : Arts::Object(StreamPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
  780.     inline StreamPlayObject(const StreamPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
  781.     inline StreamPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  782.     inline static StreamPlayObject null() {return StreamPlayObject((StreamPlayObject_base*)0);}
  783.     inline static StreamPlayObject _from_base(StreamPlayObject_base* b) {return StreamPlayObject(b);}
  784.     inline StreamPlayObject& operator=(const StreamPlayObject& target) {
  785.         if (_pool == target._pool) return *this;
  786.         _pool->Dec();
  787.         _pool = target._pool;
  788.         _cache = target._cache;
  789.         _pool->Inc();
  790.         return *this;
  791.     }
  792.     inline operator Arts::PlayObject() const { return Arts::PlayObject(*_pool); }
  793.     inline operator Arts::PlayObject_private() const { return Arts::PlayObject_private(*_pool); }
  794.     inline StreamPlayObject_base* _base() {return _cache?_cache:_method_call();}
  795.  
  796.     inline std::string description();
  797.     inline Arts::poTime currentTime();
  798.     inline Arts::poTime overallTime();
  799.     inline Arts::poCapabilities capabilities();
  800.     inline std::string mediaName();
  801.     inline Arts::poState state();
  802.     inline void play();
  803.     inline void seek(const Arts::poTime& newTime);
  804.     inline void pause();
  805.     inline void halt();
  806.     inline bool loadMedia(const std::string& filename);
  807.     inline bool streamMedia(Arts::InputStream instream);
  808.     inline Arts::InputStream inputStream();
  809. };
  810.  
  811. class ARTS_EXPORT PitchablePlayObject_base : virtual public Arts::Object_base {
  812. public:
  813.     static unsigned long _IID; // interface ID
  814.  
  815.     static PitchablePlayObject_base *_create(const std::string& subClass = "Arts::PitchablePlayObject");
  816.     static PitchablePlayObject_base *_fromString(const std::string& objectref);
  817.     static PitchablePlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  818.  
  819.     static PitchablePlayObject_base *_fromDynamicCast(const Arts::Object& object);
  820.     inline PitchablePlayObject_base *_copy() {
  821.         assert(_refCnt > 0);
  822.         _refCnt++;
  823.         return this;
  824.     }
  825.  
  826.     virtual std::vector<std::string> _defaultPortsIn() const;
  827.     virtual std::vector<std::string> _defaultPortsOut() const;
  828.  
  829.     void *_cast(unsigned long iid);
  830.  
  831.     virtual float speed() = 0;
  832.     virtual void speed(float newValue) = 0;
  833. };
  834.  
  835. class ARTS_EXPORT PitchablePlayObject_stub : virtual public PitchablePlayObject_base, virtual public Arts::Object_stub {
  836. protected:
  837.     PitchablePlayObject_stub();
  838.  
  839. public:
  840.     PitchablePlayObject_stub(Arts::Connection *connection, long objectID);
  841.  
  842.     float speed();
  843.     void speed(float newValue);
  844. };
  845.  
  846. class ARTS_EXPORT PitchablePlayObject_skel : virtual public PitchablePlayObject_base, virtual public Arts::Object_skel {
  847. protected:
  848.     // emitters for change notifications
  849.     inline void speed_changed(float newValue) {
  850.         _emit_changed("speed_changed",newValue);
  851.     }
  852.  
  853. public:
  854.     PitchablePlayObject_skel();
  855.  
  856.     static std::string _interfaceNameSkel();
  857.     std::string _interfaceName();
  858.     bool _isCompatibleWith(const std::string& interfacename);
  859.     void _buildMethodTable();
  860.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  861. };
  862.  
  863. }
  864. #include "reference.h"
  865. namespace Arts {
  866. class ARTS_EXPORT PitchablePlayObject : public Arts::Object {
  867. private:
  868.     static Arts::Object_base* _Creator();
  869.     PitchablePlayObject_base *_cache;
  870.     inline PitchablePlayObject_base *_method_call() {
  871.         _pool->checkcreate();
  872.         if(_pool->base) {
  873.             _cache=(PitchablePlayObject_base *)_pool->base->_cast(PitchablePlayObject_base::_IID);
  874.             assert(_cache);
  875.         }
  876.         return _cache;
  877.     }
  878.  
  879. protected:
  880.     inline PitchablePlayObject(PitchablePlayObject_base* b) : Arts::Object(b), _cache(0) {}
  881.  
  882.  
  883. public:
  884.     typedef PitchablePlayObject_base _base_class;
  885.  
  886.     inline PitchablePlayObject() : Arts::Object(_Creator), _cache(0) {}
  887.     inline PitchablePlayObject(const Arts::SubClass& s) :
  888.         Arts::Object(PitchablePlayObject_base::_create(s.string())), _cache(0) {}
  889.     inline PitchablePlayObject(const Arts::Reference &r) :
  890.         Arts::Object(r.isString()?(PitchablePlayObject_base::_fromString(r.string())):(PitchablePlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
  891.     inline PitchablePlayObject(const Arts::DynamicCast& c) : Arts::Object(PitchablePlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
  892.     inline PitchablePlayObject(const PitchablePlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
  893.     inline PitchablePlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  894.     inline static PitchablePlayObject null() {return PitchablePlayObject((PitchablePlayObject_base*)0);}
  895.     inline static PitchablePlayObject _from_base(PitchablePlayObject_base* b) {return PitchablePlayObject(b);}
  896.     inline PitchablePlayObject& operator=(const PitchablePlayObject& target) {
  897.         if (_pool == target._pool) return *this;
  898.         _pool->Dec();
  899.         _pool = target._pool;
  900.         _cache = target._cache;
  901.         _pool->Inc();
  902.         return *this;
  903.     }
  904.     inline PitchablePlayObject_base* _base() {return _cache?_cache:_method_call();}
  905.  
  906.     inline float speed();
  907.     inline void speed(float _newValue);
  908. };
  909.  
  910. class ARTS_EXPORT VideoPlayObject_base : virtual public Arts::Object_base {
  911. public:
  912.     static unsigned long _IID; // interface ID
  913.  
  914.     static VideoPlayObject_base *_create(const std::string& subClass = "Arts::VideoPlayObject");
  915.     static VideoPlayObject_base *_fromString(const std::string& objectref);
  916.     static VideoPlayObject_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  917.  
  918.     static VideoPlayObject_base *_fromDynamicCast(const Arts::Object& object);
  919.     inline VideoPlayObject_base *_copy() {
  920.         assert(_refCnt > 0);
  921.         _refCnt++;
  922.         return this;
  923.     }
  924.  
  925.     virtual std::vector<std::string> _defaultPortsIn() const;
  926.     virtual std::vector<std::string> _defaultPortsOut() const;
  927.  
  928.     void *_cast(unsigned long iid);
  929.  
  930.     virtual long x11WindowId() = 0;
  931.     virtual void x11WindowId(long newValue) = 0;
  932.     virtual long x11Snapshot() = 0;
  933. };
  934.  
  935. class ARTS_EXPORT VideoPlayObject_stub : virtual public VideoPlayObject_base, virtual public Arts::Object_stub {
  936. protected:
  937.     VideoPlayObject_stub();
  938.  
  939. public:
  940.     VideoPlayObject_stub(Arts::Connection *connection, long objectID);
  941.  
  942.     long x11WindowId();
  943.     void x11WindowId(long newValue);
  944.     long x11Snapshot();
  945. };
  946.  
  947. class ARTS_EXPORT VideoPlayObject_skel : virtual public VideoPlayObject_base, virtual public Arts::Object_skel {
  948. protected:
  949.     // emitters for change notifications
  950.     inline void x11WindowId_changed(long newValue) {
  951.         _emit_changed("x11WindowId_changed",newValue);
  952.     }
  953.  
  954. public:
  955.     VideoPlayObject_skel();
  956.  
  957.     static std::string _interfaceNameSkel();
  958.     std::string _interfaceName();
  959.     bool _isCompatibleWith(const std::string& interfacename);
  960.     void _buildMethodTable();
  961.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  962. };
  963.  
  964. }
  965. #include "reference.h"
  966. namespace Arts {
  967. class ARTS_EXPORT VideoPlayObject : public Arts::Object {
  968. private:
  969.     static Arts::Object_base* _Creator();
  970.     VideoPlayObject_base *_cache;
  971.     inline VideoPlayObject_base *_method_call() {
  972.         _pool->checkcreate();
  973.         if(_pool->base) {
  974.             _cache=(VideoPlayObject_base *)_pool->base->_cast(VideoPlayObject_base::_IID);
  975.             assert(_cache);
  976.         }
  977.         return _cache;
  978.     }
  979.  
  980. protected:
  981.     inline VideoPlayObject(VideoPlayObject_base* b) : Arts::Object(b), _cache(0) {}
  982.  
  983.  
  984. public:
  985.     typedef VideoPlayObject_base _base_class;
  986.  
  987.     inline VideoPlayObject() : Arts::Object(_Creator), _cache(0) {}
  988.     inline VideoPlayObject(const Arts::SubClass& s) :
  989.         Arts::Object(VideoPlayObject_base::_create(s.string())), _cache(0) {}
  990.     inline VideoPlayObject(const Arts::Reference &r) :
  991.         Arts::Object(r.isString()?(VideoPlayObject_base::_fromString(r.string())):(VideoPlayObject_base::_fromReference(r.reference(),true))), _cache(0) {}
  992.     inline VideoPlayObject(const Arts::DynamicCast& c) : Arts::Object(VideoPlayObject_base::_fromDynamicCast(c.object())), _cache(0) {}
  993.     inline VideoPlayObject(const VideoPlayObject& target) : Arts::Object(target._pool), _cache(target._cache) {}
  994.     inline VideoPlayObject(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  995.     inline static VideoPlayObject null() {return VideoPlayObject((VideoPlayObject_base*)0);}
  996.     inline static VideoPlayObject _from_base(VideoPlayObject_base* b) {return VideoPlayObject(b);}
  997.     inline VideoPlayObject& operator=(const VideoPlayObject& target) {
  998.         if (_pool == target._pool) return *this;
  999.         _pool->Dec();
  1000.         _pool = target._pool;
  1001.         _cache = target._cache;
  1002.         _pool->Inc();
  1003.         return *this;
  1004.     }
  1005.     inline VideoPlayObject_base* _base() {return _cache?_cache:_method_call();}
  1006.  
  1007.     inline long x11WindowId();
  1008.     inline void x11WindowId(long _newValue);
  1009.     inline long x11Snapshot();
  1010. };
  1011.  
  1012. class ARTS_EXPORT PlayObjectFactoryV2_base : virtual public Arts::PlayObjectFactory_base {
  1013. public:
  1014.     static unsigned long _IID; // interface ID
  1015.  
  1016.     static PlayObjectFactoryV2_base *_create(const std::string& subClass = "Arts::PlayObjectFactoryV2");
  1017.     static PlayObjectFactoryV2_base *_fromString(const std::string& objectref);
  1018.     static PlayObjectFactoryV2_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  1019.  
  1020.     static PlayObjectFactoryV2_base *_fromDynamicCast(const Arts::Object& object);
  1021.     inline PlayObjectFactoryV2_base *_copy() {
  1022.         assert(_refCnt > 0);
  1023.         _refCnt++;
  1024.         return this;
  1025.     }
  1026.  
  1027.     virtual std::vector<std::string> _defaultPortsIn() const;
  1028.     virtual std::vector<std::string> _defaultPortsOut() const;
  1029.  
  1030.     void *_cast(unsigned long iid);
  1031.  
  1032.     virtual Arts::PlayObject createPlayObjectForURL(const std::string& url, const std::string& mimetype, bool createBUS) = 0;
  1033.     virtual Arts::PlayObject createPlayObjectForStream(Arts::InputStream instream, const std::string& mimetype, bool createBUS) = 0;
  1034. };
  1035.  
  1036. class ARTS_EXPORT PlayObjectFactoryV2_stub : virtual public PlayObjectFactoryV2_base, virtual public Arts::PlayObjectFactory_stub {
  1037. protected:
  1038.     PlayObjectFactoryV2_stub();
  1039.  
  1040. public:
  1041.     PlayObjectFactoryV2_stub(Arts::Connection *connection, long objectID);
  1042.  
  1043.     Arts::PlayObject createPlayObjectForURL(const std::string& url, const std::string& mimetype, bool createBUS);
  1044.     Arts::PlayObject createPlayObjectForStream(Arts::InputStream instream, const std::string& mimetype, bool createBUS);
  1045. };
  1046.  
  1047. class ARTS_EXPORT PlayObjectFactoryV2_skel : virtual public PlayObjectFactoryV2_base, virtual public Arts::PlayObjectFactory_skel {
  1048. public:
  1049.     PlayObjectFactoryV2_skel();
  1050.  
  1051.     static std::string _interfaceNameSkel();
  1052.     std::string _interfaceName();
  1053.     bool _isCompatibleWith(const std::string& interfacename);
  1054.     void _buildMethodTable();
  1055.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  1056. };
  1057.  
  1058. }
  1059. #include "reference.h"
  1060. namespace Arts {
  1061. class ARTS_EXPORT PlayObjectFactoryV2 : public Arts::Object {
  1062. private:
  1063.     static Arts::Object_base* _Creator();
  1064.     PlayObjectFactoryV2_base *_cache;
  1065.     inline PlayObjectFactoryV2_base *_method_call() {
  1066.         _pool->checkcreate();
  1067.         if(_pool->base) {
  1068.             _cache=(PlayObjectFactoryV2_base *)_pool->base->_cast(PlayObjectFactoryV2_base::_IID);
  1069.             assert(_cache);
  1070.         }
  1071.         return _cache;
  1072.     }
  1073.  
  1074. protected:
  1075.     inline PlayObjectFactoryV2(PlayObjectFactoryV2_base* b) : Arts::Object(b), _cache(0) {}
  1076.  
  1077.  
  1078. public:
  1079.     typedef PlayObjectFactoryV2_base _base_class;
  1080.  
  1081.     inline PlayObjectFactoryV2() : Arts::Object(_Creator), _cache(0) {}
  1082.     inline PlayObjectFactoryV2(const Arts::SubClass& s) :
  1083.         Arts::Object(PlayObjectFactoryV2_base::_create(s.string())), _cache(0) {}
  1084.     inline PlayObjectFactoryV2(const Arts::Reference &r) :
  1085.         Arts::Object(r.isString()?(PlayObjectFactoryV2_base::_fromString(r.string())):(PlayObjectFactoryV2_base::_fromReference(r.reference(),true))), _cache(0) {}
  1086.     inline PlayObjectFactoryV2(const Arts::DynamicCast& c) : Arts::Object(PlayObjectFactoryV2_base::_fromDynamicCast(c.object())), _cache(0) {}
  1087.     inline PlayObjectFactoryV2(const PlayObjectFactoryV2& target) : Arts::Object(target._pool), _cache(target._cache) {}
  1088.     inline PlayObjectFactoryV2(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  1089.     inline static PlayObjectFactoryV2 null() {return PlayObjectFactoryV2((PlayObjectFactoryV2_base*)0);}
  1090.     inline static PlayObjectFactoryV2 _from_base(PlayObjectFactoryV2_base* b) {return PlayObjectFactoryV2(b);}
  1091.     inline PlayObjectFactoryV2& operator=(const PlayObjectFactoryV2& target) {
  1092.         if (_pool == target._pool) return *this;
  1093.         _pool->Dec();
  1094.         _pool = target._pool;
  1095.         _cache = target._cache;
  1096.         _pool->Inc();
  1097.         return *this;
  1098.     }
  1099.     inline operator Arts::PlayObjectFactory() const { return Arts::PlayObjectFactory(*_pool); }
  1100.     inline PlayObjectFactoryV2_base* _base() {return _cache?_cache:_method_call();}
  1101.  
  1102.     inline Arts::PlayObject createPlayObject(const std::string& filename);
  1103.     inline Arts::PlayObject createPlayObjectForURL(const std::string& url, const std::string& mimetype, bool createBUS);
  1104.     inline Arts::PlayObject createPlayObjectForStream(Arts::InputStream instream, const std::string& mimetype, bool createBUS);
  1105. };
  1106.  
  1107. }
  1108. // Forward wrapper calls to _base classes:
  1109.  
  1110. inline bool Arts::PlayObject_private::loadMedia(const std::string& filename)
  1111. {
  1112.     return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
  1113. }
  1114.  
  1115. inline bool Arts::PlayObject::loadMedia(const std::string& filename)
  1116. {
  1117.     return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
  1118. }
  1119.  
  1120. inline std::string Arts::PlayObject::description()
  1121. {
  1122.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
  1123. }
  1124.  
  1125. inline Arts::poTime Arts::PlayObject::currentTime()
  1126. {
  1127.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
  1128. }
  1129.  
  1130. inline Arts::poTime Arts::PlayObject::overallTime()
  1131. {
  1132.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
  1133. }
  1134.  
  1135. inline Arts::poCapabilities Arts::PlayObject::capabilities()
  1136. {
  1137.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
  1138. }
  1139.  
  1140. inline std::string Arts::PlayObject::mediaName()
  1141. {
  1142.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
  1143. }
  1144.  
  1145. inline Arts::poState Arts::PlayObject::state()
  1146. {
  1147.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
  1148. }
  1149.  
  1150. inline void Arts::PlayObject::play()
  1151. {
  1152.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
  1153. }
  1154.  
  1155. inline void Arts::PlayObject::seek(const Arts::poTime& newTime)
  1156. {
  1157.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
  1158. }
  1159.  
  1160. inline void Arts::PlayObject::pause()
  1161. {
  1162.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
  1163. }
  1164.  
  1165. inline void Arts::PlayObject::halt()
  1166. {
  1167.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
  1168. }
  1169.  
  1170. inline Arts::PlayObject Arts::PlayObjectFactory::createPlayObject(const std::string& filename)
  1171. {
  1172.     return _cache?static_cast<Arts::PlayObjectFactory_base*>(_cache)->createPlayObject(filename):static_cast<Arts::PlayObjectFactory_base*>(_method_call())->createPlayObject(filename);
  1173. }
  1174.  
  1175. inline Arts::AutoSuspendState Arts::InputStream::autoSuspend()
  1176. {
  1177.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1178. }
  1179.  
  1180. inline void Arts::InputStream::start()
  1181. {
  1182.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1183. }
  1184.  
  1185. inline void Arts::InputStream::stop()
  1186. {
  1187.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1188. }
  1189.  
  1190. inline void Arts::InputStream::streamInit()
  1191. {
  1192.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1193. }
  1194.  
  1195. inline void Arts::InputStream::streamStart()
  1196. {
  1197.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1198. }
  1199.  
  1200. inline void Arts::InputStream::streamEnd()
  1201. {
  1202.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1203. }
  1204.  
  1205. inline bool Arts::InputStream::eof()
  1206. {
  1207.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->eof():static_cast<Arts::InputStream_base*>(_method_call())->eof();
  1208. }
  1209.  
  1210. inline long Arts::InputStream::size()
  1211. {
  1212.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->size():static_cast<Arts::InputStream_base*>(_method_call())->size();
  1213. }
  1214.  
  1215. inline bool Arts::InputStream::seekOk()
  1216. {
  1217.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seekOk():static_cast<Arts::InputStream_base*>(_method_call())->seekOk();
  1218. }
  1219.  
  1220. inline long Arts::InputStream::seek(long position)
  1221. {
  1222.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seek(position):static_cast<Arts::InputStream_base*>(_method_call())->seek(position);
  1223. }
  1224.  
  1225. inline bool Arts::FileInputStream::eof()
  1226. {
  1227.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->eof():static_cast<Arts::InputStream_base*>(_method_call())->eof();
  1228. }
  1229.  
  1230. inline long Arts::FileInputStream::size()
  1231. {
  1232.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->size():static_cast<Arts::InputStream_base*>(_method_call())->size();
  1233. }
  1234.  
  1235. inline bool Arts::FileInputStream::seekOk()
  1236. {
  1237.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seekOk():static_cast<Arts::InputStream_base*>(_method_call())->seekOk();
  1238. }
  1239.  
  1240. inline long Arts::FileInputStream::seek(long position)
  1241. {
  1242.     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seek(position):static_cast<Arts::InputStream_base*>(_method_call())->seek(position);
  1243. }
  1244.  
  1245. inline Arts::AutoSuspendState Arts::FileInputStream::autoSuspend()
  1246. {
  1247.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1248. }
  1249.  
  1250. inline void Arts::FileInputStream::start()
  1251. {
  1252.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1253. }
  1254.  
  1255. inline void Arts::FileInputStream::stop()
  1256. {
  1257.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1258. }
  1259.  
  1260. inline void Arts::FileInputStream::streamInit()
  1261. {
  1262.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1263. }
  1264.  
  1265. inline void Arts::FileInputStream::streamStart()
  1266. {
  1267.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1268. }
  1269.  
  1270. inline void Arts::FileInputStream::streamEnd()
  1271. {
  1272.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1273. }
  1274.  
  1275. inline std::string Arts::FileInputStream::filename()
  1276. {
  1277.     return _cache?static_cast<Arts::FileInputStream_base*>(_cache)->filename():static_cast<Arts::FileInputStream_base*>(_method_call())->filename();
  1278. }
  1279.  
  1280. inline void Arts::FileInputStream::filename(const std::string& _newValue)
  1281. {
  1282.      _cache?static_cast<Arts::FileInputStream_base*>(_cache)->filename(_newValue):static_cast<Arts::FileInputStream_base*>(_method_call())->filename(_newValue);
  1283. }
  1284.  
  1285. inline bool Arts::FileInputStream::open(const std::string& filename)
  1286. {
  1287.     return _cache?static_cast<Arts::FileInputStream_base*>(_cache)->open(filename):static_cast<Arts::FileInputStream_base*>(_method_call())->open(filename);
  1288. }
  1289.  
  1290. inline Arts::AutoSuspendState Arts::StdoutWriter::autoSuspend()
  1291. {
  1292.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1293. }
  1294.  
  1295. inline void Arts::StdoutWriter::start()
  1296. {
  1297.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1298. }
  1299.  
  1300. inline void Arts::StdoutWriter::stop()
  1301. {
  1302.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1303. }
  1304.  
  1305. inline void Arts::StdoutWriter::streamInit()
  1306. {
  1307.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1308. }
  1309.  
  1310. inline void Arts::StdoutWriter::streamStart()
  1311. {
  1312.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1313. }
  1314.  
  1315. inline void Arts::StdoutWriter::streamEnd()
  1316. {
  1317.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1318. }
  1319.  
  1320. inline std::string Arts::StreamPlayObject::description()
  1321. {
  1322.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->description():static_cast<Arts::PlayObject_base*>(_method_call())->description();
  1323. }
  1324.  
  1325. inline Arts::poTime Arts::StreamPlayObject::currentTime()
  1326. {
  1327.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->currentTime():static_cast<Arts::PlayObject_base*>(_method_call())->currentTime();
  1328. }
  1329.  
  1330. inline Arts::poTime Arts::StreamPlayObject::overallTime()
  1331. {
  1332.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->overallTime():static_cast<Arts::PlayObject_base*>(_method_call())->overallTime();
  1333. }
  1334.  
  1335. inline Arts::poCapabilities Arts::StreamPlayObject::capabilities()
  1336. {
  1337.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->capabilities():static_cast<Arts::PlayObject_base*>(_method_call())->capabilities();
  1338. }
  1339.  
  1340. inline std::string Arts::StreamPlayObject::mediaName()
  1341. {
  1342.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->mediaName():static_cast<Arts::PlayObject_base*>(_method_call())->mediaName();
  1343. }
  1344.  
  1345. inline Arts::poState Arts::StreamPlayObject::state()
  1346. {
  1347.     return _cache?static_cast<Arts::PlayObject_base*>(_cache)->state():static_cast<Arts::PlayObject_base*>(_method_call())->state();
  1348. }
  1349.  
  1350. inline void Arts::StreamPlayObject::play()
  1351. {
  1352.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->play():static_cast<Arts::PlayObject_base*>(_method_call())->play();
  1353. }
  1354.  
  1355. inline void Arts::StreamPlayObject::seek(const Arts::poTime& newTime)
  1356. {
  1357.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->seek(newTime):static_cast<Arts::PlayObject_base*>(_method_call())->seek(newTime);
  1358. }
  1359.  
  1360. inline void Arts::StreamPlayObject::pause()
  1361. {
  1362.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->pause():static_cast<Arts::PlayObject_base*>(_method_call())->pause();
  1363. }
  1364.  
  1365. inline void Arts::StreamPlayObject::halt()
  1366. {
  1367.      _cache?static_cast<Arts::PlayObject_base*>(_cache)->halt():static_cast<Arts::PlayObject_base*>(_method_call())->halt();
  1368. }
  1369.  
  1370. inline bool Arts::StreamPlayObject::loadMedia(const std::string& filename)
  1371. {
  1372.     return _cache?static_cast<Arts::PlayObject_private_base*>(_cache)->loadMedia(filename):static_cast<Arts::PlayObject_private_base*>(_method_call())->loadMedia(filename);
  1373. }
  1374.  
  1375. inline bool Arts::StreamPlayObject::streamMedia(Arts::InputStream instream)
  1376. {
  1377.     return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->streamMedia(instream):static_cast<Arts::StreamPlayObject_base*>(_method_call())->streamMedia(instream);
  1378. }
  1379.  
  1380. inline Arts::InputStream Arts::StreamPlayObject::inputStream()
  1381. {
  1382.     return _cache?static_cast<Arts::StreamPlayObject_base*>(_cache)->inputStream():static_cast<Arts::StreamPlayObject_base*>(_method_call())->inputStream();
  1383. }
  1384.  
  1385. inline float Arts::PitchablePlayObject::speed()
  1386. {
  1387.     return _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed():static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed();
  1388. }
  1389.  
  1390. inline void Arts::PitchablePlayObject::speed(float _newValue)
  1391. {
  1392.      _cache?static_cast<Arts::PitchablePlayObject_base*>(_cache)->speed(_newValue):static_cast<Arts::PitchablePlayObject_base*>(_method_call())->speed(_newValue);
  1393. }
  1394.  
  1395. inline long Arts::VideoPlayObject::x11WindowId()
  1396. {
  1397.     return _cache?static_cast<Arts::VideoPlayObject_base*>(_cache)->x11WindowId():static_cast<Arts::VideoPlayObject_base*>(_method_call())->x11WindowId();
  1398. }
  1399.  
  1400. inline void Arts::VideoPlayObject::x11WindowId(long _newValue)
  1401. {
  1402.      _cache?static_cast<Arts::VideoPlayObject_base*>(_cache)->x11WindowId(_newValue):static_cast<Arts::VideoPlayObject_base*>(_method_call())->x11WindowId(_newValue);
  1403. }
  1404.  
  1405. inline long Arts::VideoPlayObject::x11Snapshot()
  1406. {
  1407.     return _cache?static_cast<Arts::VideoPlayObject_base*>(_cache)->x11Snapshot():static_cast<Arts::VideoPlayObject_base*>(_method_call())->x11Snapshot();
  1408. }
  1409.  
  1410. inline Arts::PlayObject Arts::PlayObjectFactoryV2::createPlayObject(const std::string& filename)
  1411. {
  1412.     return _cache?static_cast<Arts::PlayObjectFactory_base*>(_cache)->createPlayObject(filename):static_cast<Arts::PlayObjectFactory_base*>(_method_call())->createPlayObject(filename);
  1413. }
  1414.  
  1415. inline Arts::PlayObject Arts::PlayObjectFactoryV2::createPlayObjectForURL(const std::string& url, const std::string& mimetype, bool createBUS)
  1416. {
  1417.     return _cache?static_cast<Arts::PlayObjectFactoryV2_base*>(_cache)->createPlayObjectForURL(url, mimetype, createBUS):static_cast<Arts::PlayObjectFactoryV2_base*>(_method_call())->createPlayObjectForURL(url, mimetype, createBUS);
  1418. }
  1419.  
  1420. inline Arts::PlayObject Arts::PlayObjectFactoryV2::createPlayObjectForStream(Arts::InputStream instream, const std::string& mimetype, bool createBUS)
  1421. {
  1422.     return _cache?static_cast<Arts::PlayObjectFactoryV2_base*>(_cache)->createPlayObjectForStream(instream, mimetype, createBUS):static_cast<Arts::PlayObjectFactoryV2_base*>(_method_call())->createPlayObjectForStream(instream, mimetype, createBUS);
  1423. }
  1424.  
  1425. #endif /* KMEDIA2_H */
  1426.